mem

What is mem?

The 'mem' npm package is a utility for memoizing functions, which means it caches the result of function calls based on the arguments provided. This can significantly improve performance for expensive or frequently called functions by avoiding redundant computations.

What are mem's main functionalities?

Basic Memoization

This feature allows you to memoize a function so that it caches the result of function calls based on the arguments. Subsequent calls with the same arguments will return the cached result instead of recalculating.

const mem = require('mem');

const expensiveFunction = (input) => {
  console.log('Function called with', input);
  return input * 2;
};

const memoizedFunction = mem(expensiveFunction);

console.log(memoizedFunction(2)); // Function called with 2, 4
console.log(memoizedFunction(2)); // 4 (cached result)

Custom Cache Key

This feature allows you to define a custom cache key function, which determines how the cache key is generated based on the function arguments. This can be useful for more complex caching strategies.

const mem = require('mem');

const expensiveFunction = (input) => {
  console.log('Function called with', input);
  return input * 2;
};

const customCacheKey = (args) => args[0] % 2; // Cache based on even/odd
const memoizedFunction = mem(expensiveFunction, { cacheKey: customCacheKey });

console.log(memoizedFunction(2)); // Function called with 2, 4
console.log(memoizedFunction(4)); // 4 (cached result)
console.log(memoizedFunction(3)); // Function called with 3, 6

Cache Expiration

This feature allows you to set a maximum age for cache entries. After the specified time, the cache entry will expire, and the function will be called again to recalculate the result.

const mem = require('mem');

const expensiveFunction = (input) => {
  console.log('Function called with', input);
  return input * 2;
};

const memoizedFunction = mem(expensiveFunction, { maxAge: 1000 });

console.log(memoizedFunction(2)); // Function called with 2, 4
setTimeout(() => {
  console.log(memoizedFunction(2)); // Function called with 2, 4 (after 1 second, cache expired)
}, 1500);

Other packages similar to mem

lodash.memoize

Lodash's memoize function provides similar functionality to 'mem' by caching the result of function calls. It is part of the larger Lodash utility library, which offers a wide range of utility functions for JavaScript. Compared to 'mem', lodash.memoize is more lightweight but lacks some advanced features like cache expiration.

memoizee

Memoizee is a full-featured memoization library that offers a wide range of options, including cache expiration, custom cache keys, and more. It is more feature-rich compared to 'mem' but also comes with a larger footprint.

moize

Moize is another memoization library that offers a balance between performance and features. It supports cache expiration, custom cache keys, and other advanced options. It is similar to 'mem' in terms of functionality but aims to provide better performance and more configuration options.

README

mem

Memoize functions - An optimization used to speed up consecutive function calls by caching the result of calls with identical input

Memory is automatically released when an item expires.

Install

$ npm install mem

Usage

const mem = require('mem');

let i = 0;
const counter = () => ++i;
const memoized = mem(counter);

memoized('foo');
//=> 1

// Cached as it's the same arguments
memoized('foo');
//=> 1

// Not cached anymore as the arguments changed
memoized('bar');
//=> 2

memoized('bar');
//=> 2

Works fine with promise returning functions

const mem = require('mem');

let i = 0;
const counter = async () => ++i;
const memoized = mem(counter);

(async () => {
	console.log(await memoized());
	//=> 1

	// The return value didn't increase as it's cached
	console.log(await memoized());
	//=> 1
})();

const mem = require('mem');
const got = require('got');
const delay = require('delay');

const memGot = mem(got, {maxAge: 1000});

(async () => {
	await memGot('sindresorhus.com');

	// This call is cached
	await memGot('sindresorhus.com');

	await delay(2000);

	// This call is not cached as the cache has expired
	await memGot('sindresorhus.com');
})();

API

mem(fn, options?)

fn

Type: Function

Function to be memoized.

options

Type: object

maxAge

Type: number
Default: Infinity

Milliseconds until the cache expires.

cacheKey

Type: Function

Determines the cache key for storing the result based on the function arguments. By default, if there's only one argument and it's a primitive, it's used directly as a key (if it's a function, its reference will be used as key), otherwise it's all the function arguments JSON stringified as an array.

You could for example change it to only cache on the first argument x => JSON.stringify(x).

cache

Type: object
Default: new Map()

Use a different cache storage. Must implement the following methods: .has(key), .get(key), .set(key, value), .delete(key), and optionally .clear(). You could for example use a WeakMap instead or quick-lru for a LRU cache.

cachePromiseRejection

Type: boolean
Default: true

Cache rejected promises.

mem.clear(fn)

Clear all cached data of a memoized function.

fn

Type: Function

Memoized function.

Tips

Cache statistics

If you want to know how many times your cache had a hit or a miss, you can make use of stats-map as a replacement for the default cache.

Example

const mem = require('mem');
const StatsMap = require('stats-map');
const got = require('got');

const cache = new StatsMap();
const memGot = mem(got, {cache});

(async () => {
	await memGot('sindresorhus.com');
	await memGot('sindresorhus.com');
	await memGot('sindresorhus.com');

	console.log(cache.stats);
	//=> {hits: 2, misses: 1}
})();

Related

• p-memoize - Memoize promise-returning & async functions

---

Get professional support for this package with a Tidelift subscription
_{Tidelift helps make open source sustainable for maintainers while giving companies
assurances about security, maintenance, and licensing for their dependencies.}